Chip 2007 January, February, March & April/Chip-Cover-CD-2007-02.iso/Pakiet bezpieczenstwa/mini Pentoo LiveCD 2006.1/mpentoo-2006.1.iso/livecd.squashfs/usr/lib/python2.4/test/test_weakref.pyc

Python Compiled Bytecode | 2005-10-18 | 34KB | 972 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.4)

import gc
import sys
import unittest
import UserList
import weakref
from test import test_support

class C:

    def method(self):
        pass



class Callable:
    bar = None

    def __call__(self, x):
        self.bar = x



def create_function():

    def f():
        pass

    return f


def create_bound_method():
    return C().method


def create_unbound_method():
    return C.method


class TestBase(unittest.TestCase):

    def setUp(self):
        self.cbcalled = 0


    def callback(self, ref):
        self.cbcalled += 1



class ReferencesTestCase(TestBase):

    def test_basic_ref(self):
        self.check_basic_ref(C)
        self.check_basic_ref(create_function)
        self.check_basic_ref(create_bound_method)
        self.check_basic_ref(create_unbound_method)
        o = C()
        wr = weakref.ref(o)
        `wr`
        del o
        `wr`


    def test_basic_callback(self):
        self.check_basic_callback(C)
        self.check_basic_callback(create_function)
        self.check_basic_callback(create_bound_method)
        self.check_basic_callback(create_unbound_method)


    def test_multiple_callbacks(self):
        o = C()
        ref1 = weakref.ref(o, self.callback)
        ref2 = weakref.ref(o, self.callback)
        del o
        self.assert_(ref1() is None, 'expected reference to be invalidated')
        self.assert_(ref2() is None, 'expected reference to be invalidated')
        self.assert_(self.cbcalled == 2, 'callback not called the right number of times')


    def test_multiple_selfref_callbacks(self):

        def callback(object, self = self):
            self.ref()

        c = C()
        self.ref = weakref.ref(c, callback)
        ref1 = weakref.ref(c, callback)
        del c


    def test_proxy_ref(self):
        o = C()
        o.bar = 1
        ref1 = weakref.proxy(o, self.callback)
        ref2 = weakref.proxy(o, self.callback)
        del o

        def check(proxy):
            proxy.bar

        self.assertRaises(weakref.ReferenceError, check, ref1)
        self.assertRaises(weakref.ReferenceError, check, ref2)
        self.assertRaises(weakref.ReferenceError, bool, weakref.proxy(C()))
        self.assert_(self.cbcalled == 2)


    def check_basic_ref(self, factory):
        o = factory()
        ref = weakref.ref(o)
        self.assert_(ref() is not None, 'weak reference to live object should be live')
        o2 = ref()
        self.assert_(o is o2, '<ref>() should return original object if live')


    def check_basic_callback(self, factory):
        self.cbcalled = 0
        o = factory()
        ref = weakref.ref(o, self.callback)
        del o
        self.assert_(self.cbcalled == 1, "callback did not properly set 'cbcalled'")
        self.assert_(ref() is None, 'ref2 should be dead after deleting object reference')


    def test_ref_reuse(self):
        o = C()
        ref1 = weakref.ref(o)
        proxy = weakref.proxy(o)
        ref2 = weakref.ref(o)
        self.assert_(ref1 is ref2, 'reference object w/out callback should be re-used')
        o = C()
        proxy = weakref.proxy(o)
        ref1 = weakref.ref(o)
        ref2 = weakref.ref(o)
        self.assert_(ref1 is ref2, 'reference object w/out callback should be re-used')
        self.assert_(weakref.getweakrefcount(o) == 2, 'wrong weak ref count for object')
        del proxy
        self.assert_(weakref.getweakrefcount(o) == 1, 'wrong weak ref count for object after deleting proxy')


    def test_proxy_reuse(self):
        o = C()
        proxy1 = weakref.proxy(o)
        ref = weakref.ref(o)
        proxy2 = weakref.proxy(o)
        self.assert_(proxy1 is proxy2, 'proxy object w/out callback should have been re-used')


    def test_basic_proxy(self):
        o = C()
        self.check_proxy(o, weakref.proxy(o))
        L = UserList.UserList()
        p = weakref.proxy(L)
        self.failIf(p, 'proxy for empty UserList should be false')
        p.append(12)
        self.assertEqual(len(L), 1)
        self.failUnless(p, 'proxy for non-empty UserList should be true')
        p[:] = [
            2,
            3]
        self.assertEqual(len(L), 2)
        self.assertEqual(len(p), 2)
        self.failUnless(3 in p, "proxy didn't support __contains__() properly")
        p[1] = 5
        self.assertEqual(L[1], 5)
        self.assertEqual(p[1], 5)
        L2 = UserList.UserList(L)
        p2 = weakref.proxy(L2)
        self.assertEqual(p, p2)
        L3 = UserList.UserList(range(10))
        p3 = weakref.proxy(L3)
        self.assertEqual(L3[:], p3[:])
        self.assertEqual(L3[5:], p3[5:])
        self.assertEqual(L3[:5], p3[:5])
        self.assertEqual(L3[2:5], p3[2:5])


    def test_shared_ref_without_callback(self):
        self.check_shared_without_callback(weakref.ref)


    def test_shared_proxy_without_callback(self):
        self.check_shared_without_callback(weakref.proxy)


    def check_shared_without_callback(self, makeref):
        o = Object(1)
        p1 = makeref(o, None)
        p2 = makeref(o, None)
        self.assert_(p1 is p2, 'both callbacks were None in the C API')
        del p1
        del p2
        p1 = makeref(o)
        p2 = makeref(o, None)
        self.assert_(p1 is p2, 'callbacks were NULL, None in the C API')
        del p1
        del p2
        p1 = makeref(o)
        p2 = makeref(o)
        self.assert_(p1 is p2, 'both callbacks were NULL in the C API')
        del p1
        del p2
        p1 = makeref(o, None)
        p2 = makeref(o)
        self.assert_(p1 is p2, 'callbacks were None, NULL in the C API')


    def test_callable_proxy(self):
        o = Callable()
        ref1 = weakref.proxy(o)
        self.check_proxy(o, ref1)
        self.assert_(type(ref1) is weakref.CallableProxyType, 'proxy is not of callable type')
        ref1('twinkies!')
        self.assert_(o.bar == 'twinkies!', 'call through proxy not passed through to original')
        ref1(x = 'Splat.')
        self.assert_(o.bar == 'Splat.', 'call through proxy not passed through to original')
        self.assertRaises(TypeError, ref1)
        self.assertRaises(TypeError, ref1, 1, 2, 3)


    def check_proxy(self, o, proxy):
        o.foo = 1
        self.assert_(proxy.foo == 1, 'proxy does not reflect attribute addition')
        o.foo = 2
        self.assert_(proxy.foo == 2, 'proxy does not reflect attribute modification')
        del o.foo
        self.assert_(not hasattr(proxy, 'foo'), 'proxy does not reflect attribute removal')
        proxy.foo = 1
        self.assert_(o.foo == 1, 'object does not reflect attribute addition via proxy')
        proxy.foo = 2
        self.assert_(o.foo == 2, 'object does not reflect attribute modification via proxy')
        del proxy.foo
        self.assert_(not hasattr(o, 'foo'), 'object does not reflect attribute removal via proxy')


    def test_proxy_deletion(self):

        class Foo:
            result = None

            def __delitem__(self, accessor):
                self.result = accessor


        g = Foo()
        f = weakref.proxy(g)
        del f[0]
        self.assertEqual(f.result, 0)


    def test_proxy_bool(self):

        class List(list):
            pass

        lyst = List()
        self.assertEqual(bool(weakref.proxy(lyst)), bool(lyst))


    def test_getweakrefcount(self):
        o = C()
        ref1 = weakref.ref(o)
        ref2 = weakref.ref(o, self.callback)
        self.assert_(weakref.getweakrefcount(o) == 2, 'got wrong number of weak reference objects')
        proxy1 = weakref.proxy(o)
        proxy2 = weakref.proxy(o, self.callback)
        self.assert_(weakref.getweakrefcount(o) == 4, 'got wrong number of weak reference objects')
        del ref1
        del ref2
        del proxy1
        del proxy2
        self.assert_(weakref.getweakrefcount(o) == 0, 'weak reference objects not unlinked from referent when discarded.')
        self.assert_(weakref.getweakrefcount(1) == 0, 'got wrong number of weak reference objects for int')


    def test_getweakrefs(self):
        o = C()
        ref1 = weakref.ref(o, self.callback)
        ref2 = weakref.ref(o, self.callback)
        del ref1
        self.assert_(weakref.getweakrefs(o) == [
            ref2], 'list of refs does not match')
        o = C()
        ref1 = weakref.ref(o, self.callback)
        ref2 = weakref.ref(o, self.callback)
        del ref2
        self.assert_(weakref.getweakrefs(o) == [
            ref1], 'list of refs does not match')
        del ref1
        self.assert_(weakref.getweakrefs(o) == [], 'list of refs not cleared')
        self.assert_(weakref.getweakrefs(1) == [], 'list of refs does not match for int')


    def test_newstyle_number_ops(self):

        class F(float):
            pass

        f = F(2.0)
        p = weakref.proxy(f)
        self.assert_(p + 1.0 == 3.0)
        self.assert_(1.0 + p == 3.0)


    def test_callbacks_protected(self):

        class BogusError(Exception):
            pass

        data = { }

        def remove(k):
            del data[k]


        def encapsulate():

            f = lambda : ()
            data[weakref.ref(f, remove)] = None
            raise BogusError


        try:
            encapsulate()
        except BogusError:
            pass

        self.fail('exception not properly restored')

        try:
            encapsulate()
        except BogusError:
            pass

        self.fail('exception not properly restored')


    def test_sf_bug_840829(self):
        import gc

        class C(object):
            pass

        c = C()
        wr = weakref.ref(c, (lambda ignore: gc.collect()))
        del c
        del wr
        c1 = C()
        c1.i = C()
        wr = weakref.ref(c1.i, (lambda ignore: gc.collect()))
        c2 = C()
        c2.c1 = c1
        del c1
        del c2


    def test_callback_in_cycle_1(self):
        import gc

        class J(object):
            pass


        class II(object):

            def acallback(self, ignore):
                self.J


        I = II()
        I.J = J
        I.wr = weakref.ref(J, I.acallback)
        del I
        del J
        del II
        gc.collect()


    def test_callback_in_cycle_2(self):
        import gc

        class J(object):
            pass


        class II:

            def acallback(self, ignore):
                self.J


        I = II()
        I.J = J
        I.wr = weakref.ref(J, I.acallback)
        del I
        del J
        del II
        gc.collect()


    def test_callback_in_cycle_3(self):
        import gc

        class C:

            def cb(self, ignore):
                self.me
                self.c1
                self.wr


        c1 = C()
        c2 = C()
        c2.me = c2
        c2.c1 = c1
        c2.wr = weakref.ref(c1, c2.cb)
        del c1
        del c2
        gc.collect()


    def test_callback_in_cycle_4(self):
        import gc

        class C(object):

            def cb(self, ignore):
                self.me
                self.c1
                self.wr



        class D:
            pass

        c1 = D()
        c2 = C()
        c2.me = c2
        c2.c1 = c1
        c2.wr = weakref.ref(c1, c2.cb)
        del c1
        del c2
        del C
        del D
        gc.collect()


    def test_callback_in_cycle_resurrection(self):
        import gc
        alist = []

        class C(object):

            def __init__(self, value):
                self.attribute = value


            def acallback(self, ignore):
                alist.append(self.c)


        c1 = C(1)
        c2 = C(2)
        c1.c = c2
        c2.c = c1
        c1.wr = weakref.ref(c2, c1.acallback)
        c2.wr = weakref.ref(c1, c2.acallback)

        def C_went_away(ignore):
            alist.append('C went away')

        wr = weakref.ref(C, C_went_away)
        del c1
        del c2
        del C
        self.assertEqual(alist, [])
        gc.collect()
        self.assertEqual(alist, [
            'C went away'])
        self.assertEqual(wr(), None)
        del alist[:]
        gc.collect()
        self.assertEqual(alist, [])


    def test_callbacks_on_callback(self):
        import gc
        alist = []

        def safe_callback(ignore):
            alist.append('safe_callback called')


        class C(object):

            def cb(self, ignore):
                alist.append('cb called')


        c = C()
        d = C()
        c.other = d
        d.other = c
        callback = c.cb
        c.wr = weakref.ref(d, callback)
        d.wr = weakref.ref(callback, d.cb)
        external_wr = weakref.ref(callback, safe_callback)
        self.assert_(external_wr() is callback)
        del callback
        del c
        del d
        del C
        self.assertEqual(alist, [])
        gc.collect()
        self.assertEqual(alist, [
            'safe_callback called'])
        self.assertEqual(external_wr(), None)
        del alist[:]
        gc.collect()
        self.assertEqual(alist, [])


    def test_gc_during_ref_creation(self):
        self.check_gc_during_creation(weakref.ref)


    def test_gc_during_proxy_creation(self):
        self.check_gc_during_creation(weakref.proxy)


    def check_gc_during_creation(self, makeref):
        thresholds = gc.get_threshold()
        gc.set_threshold(1, 1, 1)
        gc.collect()

        class A:
            pass


        def callback(*args):
            pass

        referenced = A()
        a = A()
        a.a = a
        a.wr = makeref(referenced)

        try:
            a = A()
            weakref.ref(referenced, callback)
        finally:
            gc.set_threshold(*thresholds)




class SubclassableWeakrefTestCase(unittest.TestCase):

    def test_subclass_refs(self):

        class MyRef(weakref.ref):

            def __init__(self, ob, callback = None, value = 42):
                self.value = value
                super(MyRef, self).__init__(ob, callback)


            def __call__(self):
                self.called = True
                return super(MyRef, self).__call__()


        o = Object('foo')
        mr = MyRef(o, value = 24)
        self.assert_(mr() is o)
        self.assert_(mr.called)
        self.assertEqual(mr.value, 24)
        del o
        self.assert_(mr() is None)
        self.assert_(mr.called)


    def test_subclass_refs_dont_replace_standard_refs(self):

        class MyRef(weakref.ref):
            pass

        o = Object(42)
        r1 = MyRef(o)
        r2 = weakref.ref(o)
        self.assert_(r1 is not r2)
        self.assertEqual(weakref.getweakrefs(o), [
            r2,
            r1])
        self.assertEqual(weakref.getweakrefcount(o), 2)
        r3 = MyRef(o)
        self.assertEqual(weakref.getweakrefcount(o), 3)
        refs = weakref.getweakrefs(o)
        self.assertEqual(len(refs), 3)
        self.assert_(r2 is refs[0])
        self.assert_(r1 in refs[1:])
        self.assert_(r3 in refs[1:])


    def test_subclass_refs_dont_conflate_callbacks(self):

        class MyRef(weakref.ref):
            pass

        o = Object(42)
        r1 = MyRef(o, id)
        r2 = MyRef(o, str)
        self.assert_(r1 is not r2)
        refs = weakref.getweakrefs(o)
        self.assert_(r1 in refs)
        self.assert_(r2 in refs)


    def test_subclass_refs_with_slots(self):

        class MyRef(weakref.ref):
            __slots__ = ('slot1', 'slot2')

            def __new__(type, ob, callback, slot1, slot2):
                return weakref.ref.__new__(type, ob, callback)


            def __init__(self, ob, callback, slot1, slot2):
                self.slot1 = slot1
                self.slot2 = slot2


            def meth(self):
                return self.slot1 + self.slot2


        o = Object(42)
        r = MyRef(o, None, 'abc', 'def')
        self.assertEqual(r.slot1, 'abc')
        self.assertEqual(r.slot2, 'def')
        self.assertEqual(r.meth(), 'abcdef')
        self.failIf(hasattr(r, '__dict__'))



class Object:

    def __init__(self, arg):
        self.arg = arg


    def __repr__(self):
        return '<Object %r>' % self.arg



class MappingTestCase(TestBase):
    COUNT = 10

    def test_weak_values(self):
        (dict, objects) = self.make_weak_valued_dict()
        for o in objects:
            self.assert_(weakref.getweakrefcount(o) == 1, 'wrong number of weak references to %r!' % o)
            self.assert_(o is dict[o.arg], 'wrong object returned by weak dict!')

        items1 = dict.items()
        items2 = dict.copy().items()
        items1.sort()
        items2.sort()
        self.assert_(items1 == items2, 'cloning of weak-valued dictionary did not work!')
        del items1
        del items2
        self.assert_(len(dict) == self.COUNT)
        del objects[0]
        self.assert_(len(dict) == self.COUNT - 1, 'deleting object did not cause dictionary update')
        del objects
        del o
        self.assert_(len(dict) == 0, 'deleting the values did not clear the dictionary')
        dict = weakref.WeakValueDictionary()
        self.assertRaises(KeyError, dict.__getitem__, 1)
        dict[2] = C()
        self.assertRaises(KeyError, dict.__getitem__, 2)


    def test_weak_keys(self):
        (dict, objects) = self.make_weak_keyed_dict()
        for o in objects:
            self.assert_(weakref.getweakrefcount(o) == 1, 'wrong number of weak references to %r!' % o)
            self.assert_(o.arg is dict[o], 'wrong object returned by weak dict!')

        items1 = dict.items()
        items2 = dict.copy().items()
        self.assert_(set(items1) == set(items2), 'cloning of weak-keyed dictionary did not work!')
        del items1
        del items2
        self.assert_(len(dict) == self.COUNT)
        del objects[0]
        self.assert_(len(dict) == self.COUNT - 1, 'deleting object did not cause dictionary update')
        del objects
        del o
        self.assert_(len(dict) == 0, 'deleting the keys did not clear the dictionary')
        o = Object(42)
        dict[o] = 'What is the meaning of the universe?'
        self.assert_(dict.has_key(o))
        self.assert_(not dict.has_key(34))


    def test_weak_keyed_iters(self):
        (dict, objects) = self.make_weak_keyed_dict()
        self.check_iters(dict)


    def test_weak_valued_iters(self):
        (dict, objects) = self.make_weak_valued_dict()
        self.check_iters(dict)


    def check_iters(self, dict):
        items = dict.items()
        for item in dict.iteritems():
            items.remove(item)

        self.assert_(len(items) == 0, 'iteritems() did not touch all items')
        keys = dict.keys()
        for k in dict:
            keys.remove(k)

        self.assert_(len(keys) == 0, '__iter__() did not touch all keys')
        keys = dict.keys()
        for k in dict.iterkeys():
            keys.remove(k)

        self.assert_(len(keys) == 0, 'iterkeys() did not touch all keys')
        values = dict.values()
        for v in dict.itervalues():
            values.remove(v)

        self.assert_(len(values) == 0, 'itervalues() did not touch all values')


    def test_make_weak_keyed_dict_from_dict(self):
        o = Object(3)
        dict = weakref.WeakKeyDictionary({
            o: 364 })
        self.assert_(dict[o] == 364)


    def test_make_weak_keyed_dict_from_weak_keyed_dict(self):
        o = Object(3)
        dict = weakref.WeakKeyDictionary({
            o: 364 })
        dict2 = weakref.WeakKeyDictionary(dict)
        self.assert_(dict[o] == 364)


    def make_weak_keyed_dict(self):
        dict = weakref.WeakKeyDictionary()
        objects = map(Object, range(self.COUNT))
        for o in objects:
            dict[o] = o.arg

        return (dict, objects)


    def make_weak_valued_dict(self):
        dict = weakref.WeakValueDictionary()
        objects = map(Object, range(self.COUNT))
        for o in objects:
            dict[o.arg] = o

        return (dict, objects)


    def check_popitem(self, klass, key1, value1, key2, value2):
        weakdict = klass()
        weakdict[key1] = value1
        weakdict[key2] = value2
        self.assert_(len(weakdict) == 2)
        (k, v) = weakdict.popitem()
        self.assert_(len(weakdict) == 1)
        if k is key1:
            self.assert_(v is value1)
        else:
            self.assert_(v is value2)
        (k, v) = weakdict.popitem()
        self.assert_(len(weakdict) == 0)
        if k is key1:
            self.assert_(v is value1)
        else:
            self.assert_(v is value2)


    def test_weak_valued_dict_popitem(self):
        self.check_popitem(weakref.WeakValueDictionary, 'key1', C(), 'key2', C())


    def test_weak_keyed_dict_popitem(self):
        self.check_popitem(weakref.WeakKeyDictionary, C(), 'value 1', C(), 'value 2')


    def check_setdefault(self, klass, key, value1, value2):
        self.assert_(value1 is not value2, 'invalid test -- value parameters must be distinct objects')
        weakdict = klass()
        o = weakdict.setdefault(key, value1)
        self.assert_(o is value1)
        self.assert_(weakdict.has_key(key))
        self.assert_(weakdict.get(key) is value1)
        self.assert_(weakdict[key] is value1)
        o = weakdict.setdefault(key, value2)
        self.assert_(o is value1)
        self.assert_(weakdict.has_key(key))
        self.assert_(weakdict.get(key) is value1)
        self.assert_(weakdict[key] is value1)


    def test_weak_valued_dict_setdefault(self):
        self.check_setdefault(weakref.WeakValueDictionary, 'key', C(), C())


    def test_weak_keyed_dict_setdefault(self):
        self.check_setdefault(weakref.WeakKeyDictionary, C(), 'value 1', 'value 2')


    def check_update(self, klass, dict):
        weakdict = klass()
        weakdict.update(dict)
        self.assert_(len(weakdict) == len(dict))
        for k in weakdict.keys():
            self.assert_(dict.has_key(k), 'mysterious new key appeared in weak dict')
            v = dict.get(k)
            self.assert_(v is weakdict[k])
            self.assert_(v is weakdict.get(k))

        for k in dict.keys():
            self.assert_(weakdict.has_key(k), 'original key disappeared in weak dict')
            v = dict[k]
            self.assert_(v is weakdict[k])
            self.assert_(v is weakdict.get(k))



    def test_weak_valued_dict_update(self):
        self.check_update(weakref.WeakValueDictionary, {
            1: C(),
            'a': C(),
            C(): C() })


    def test_weak_keyed_dict_update(self):
        self.check_update(weakref.WeakKeyDictionary, {
            C(): 1,
            C(): 2,
            C(): 3 })


    def test_weak_keyed_delitem(self):
        d = weakref.WeakKeyDictionary()
        o1 = Object('1')
        o2 = Object('2')
        d[o1] = 'something'
        d[o2] = 'something'
        self.assert_(len(d) == 2)
        del d[o1]
        self.assert_(len(d) == 1)
        self.assert_(d.keys() == [
            o2])


    def test_weak_valued_delitem(self):
        d = weakref.WeakValueDictionary()
        o1 = Object('1')
        o2 = Object('2')
        d['something'] = o1
        d['something else'] = o2
        self.assert_(len(d) == 2)
        del d['something']
        self.assert_(len(d) == 1)
        self.assert_(d.items() == [
            ('something else', o2)])


    def test_weak_keyed_bad_delitem(self):
        d = weakref.WeakKeyDictionary()
        o = Object('1')
        self.assertRaises(KeyError, d.__delitem__, o)
        self.assertRaises(KeyError, d.__getitem__, o)
        self.assertRaises(TypeError, d.__delitem__, 13)
        self.assertRaises(TypeError, d.__getitem__, 13)
        self.assertRaises(TypeError, d.__setitem__, 13, 13)


    def test_weak_keyed_cascading_deletes(self):
        d = weakref.WeakKeyDictionary()
        mutate = False

        class C(object):

            def __init__(self, i):
                self.value = i


            def __hash__(self):
                return hash(self.value)


            def __eq__(self, other):
                if mutate:
                    del objs[-1]

                return self.value == other.value


        objs = [ C(i) for i in range(4) ]
        for o in objs:
            d[o] = o.value

        del o
        objs = d.keys()
        objs.reverse()
        mutate = True
        count = 0
        for o in objs:
            count += 1
            del d[o]

        self.assertEqual(len(d), 0)
        self.assertEqual(count, 2)


from test import mapping_tests

class WeakValueDictionaryTestCase(mapping_tests.BasicTestMappingProtocol):
    '''Check that WeakValueDictionary conforms to the mapping protocol'''
    __ref = {
        'key1': Object(1),
        'key2': Object(2),
        'key3': Object(3) }
    type2test = weakref.WeakValueDictionary

    def _reference(self):
        return self._WeakValueDictionaryTestCase__ref.copy()



class WeakKeyDictionaryTestCase(mapping_tests.BasicTestMappingProtocol):
    '''Check that WeakKeyDictionary conforms to the mapping protocol'''
    __ref = {
        Object('key1'): 1,
        Object('key2'): 2,
        Object('key3'): 3 }
    type2test = weakref.WeakKeyDictionary

    def _reference(self):
        return self._WeakKeyDictionaryTestCase__ref.copy()


libreftest = ' Doctest for examples in the library reference: libweakref.tex\n\n>>> import weakref\n>>> class Dict(dict):\n...     pass\n...\n>>> obj = Dict(red=1, green=2, blue=3)   # this object is weak referencable\n>>> r = weakref.ref(obj)\n>>> print r()\n{\'blue\': 3, \'green\': 2, \'red\': 1}\n\n>>> import weakref\n>>> class Object:\n...     pass\n...\n>>> o = Object()\n>>> r = weakref.ref(o)\n>>> o2 = r()\n>>> o is o2\nTrue\n>>> del o, o2\n>>> print r()\nNone\n\n>>> import weakref\n>>> class ExtendedRef(weakref.ref):\n...     def __init__(self, ob, callback=None, **annotations):\n...         super(ExtendedRef, self).__init__(ob, callback)\n...         self.__counter = 0\n...         for k, v in annotations.iteritems():\n...             setattr(self, k, v)\n...     def __call__(self):\n...         \'\'\'Return a pair containing the referent and the number of\n...         times the reference has been called.\n...         \'\'\'\n...         ob = super(ExtendedRef, self).__call__()\n...         if ob is not None:\n...             self.__counter += 1\n...             ob = (ob, self.__counter)\n...         return ob\n...\n>>> class A:   # not in docs from here, just testing the ExtendedRef\n...     pass\n...\n>>> a = A()\n>>> r = ExtendedRef(a, foo=1, bar="baz")\n>>> r.foo\n1\n>>> r.bar\n\'baz\'\n>>> r()[1]\n1\n>>> r()[1]\n2\n>>> r()[0] is a\nTrue\n\n\n>>> import weakref\n>>> _id2obj_dict = weakref.WeakValueDictionary()\n>>> def remember(obj):\n...     oid = id(obj)\n...     _id2obj_dict[oid] = obj\n...     return oid\n...\n>>> def id2obj(oid):\n...     return _id2obj_dict[oid]\n...\n>>> a = A()             # from here, just testing\n>>> a_id = remember(a)\n>>> id2obj(a_id) is a\nTrue\n>>> del a\n>>> try:\n...     id2obj(a_id)\n... except KeyError:\n...     print \'OK\'\n... else:\n...     print \'WeakValueDictionary error\'\nOK\n\n'
__test__ = {
    'libreftest': libreftest }

def test_main():
    test_support.run_unittest(ReferencesTestCase, MappingTestCase, WeakValueDictionaryTestCase, WeakKeyDictionaryTestCase)
    test_support.run_doctest(sys.modules[__name__])

if __name__ == '__main__':
    test_main()